diff --git a/system/core/Common.php b/system/core/Common.php
index 3d6931b..d793754 100644
--- a/system/core/Common.php
+++ b/system/core/Common.php
@@ -132,9 +132,9 @@
 
 		$name = FALSE;
 
-		// Look for the class first in the native system/libraries folder
-		// thenin the local application/libraries folder
-		foreach (array(BASEPATH, APPPATH) as $path)
+		// Look for the class first in the local application/libraries folder
+		// then in the native system/libraries folder
+		foreach (array(APPPATH, BASEPATH) as $path)
 		{
 			if (file_exists($path.$directory.'/'.$class.'.php'))
 			{
diff --git a/user_guide/changelog.html b/user_guide/changelog.html
index 11a1537..69ba4e6 100644
--- a/user_guide/changelog.html
+++ b/user_guide/changelog.html
@@ -95,7 +95,7 @@
 	<li>Core
 		<ul>
 			<li>Changed private functions in <a href="libraries/cart.html">URI Library</a> to protected so <kdb>MY_URI</kdb> can override them.</li>
-			<li>Removed <var>CI_CORE</var> boolean constant from CodeIgniter.php (there are no longer different Reactor and Core versions).</li>
+			<li>Removed <samp>CI_CORE</samp> boolean constant from CodeIgniter.php (there are no longer different Reactor and Core versions).</li>
 		</ul>
 	</li>
 </ul>
@@ -110,7 +110,7 @@
 	<li>Fixed bug #105 that stopped query errors from being logged unless database debugging was enabled</li>
 	<li>Fixed a bug (#160) - Removed unneeded array copy in the file cache driver.</li>
 	<li>Fixed a bug (#150) - <samp>field_data()</samp> now correctly returns column length.</li>
-	<li>Fixed a bug (#8) - load_class() now looks for core classes in APPPATH first, allowing them to be replaced.</li>
+	<li>Fixed a bug (#8) - Look for core classes in <samp>APPPATH</samp> first.</li>
 	<li>Fixed a bug (#24) - ODBC database driver called incorrect parent in __construct().</li>
 	<li>Fixed a bug (#85) - OCI8 (Oracle) database <kbd>escape_str()</kbd> function did not escape correct.</li>
 	<li>Fixed a bug (#344) - Using schema found in <a href="libraries/sessions.html">Saving Session Data to a Database</a>, system would throw error "user_data does not have a default value" when deleting then creating a session.</li>
